using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("ZoneHand")]
	public class ZoneHand : Zone
	{
		public GameObject m_iPhoneCardPosition => method_3<GameObject>("m_iPhoneCardPosition");

		public GameObject m_leftArrow => method_3<GameObject>("m_leftArrow");

		public GameObject m_rightArrow => method_3<GameObject>("m_rightArrow");

		public GameObject m_manaGemPosition => method_3<GameObject>("m_manaGemPosition");

		public ManaCrystalMgr m_manaGemMgr => method_3<ManaCrystalMgr>("m_manaGemMgr");

		public GameObject m_playCardButton => method_3<GameObject>("m_playCardButton");

		public GameObject m_iPhonePreviewBone => method_3<GameObject>("m_iPhonePreviewBone");

		public Vector3 m_enlargedHandPosition => method_2<Vector3>("m_enlargedHandPosition");

		public Vector3 m_enlargedHandScale => method_2<Vector3>("m_enlargedHandScale");

		public Vector3 m_enlargedHandCardScale => method_2<Vector3>("m_enlargedHandCardScale");

		public float m_enlargedHandDefaultCardSpacing => method_2<float>("m_enlargedHandDefaultCardSpacing");

		public float m_enlargedHandCardMinX => method_2<float>("m_enlargedHandCardMinX");

		public float m_enlargedHandCardMaxX => method_2<float>("m_enlargedHandCardMaxX");

		public float m_heroWidthInHand => method_2<float>("m_heroWidthInHand");

		public float m_handHidingDistance => method_2<float>("m_handHidingDistance");

		public GameObject m_heroHitbox => method_3<GameObject>("m_heroHitbox");

		public static float MOUSE_OVER_SCALE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "MOUSE_OVER_SCALE");

		public static float HAND_SCALE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "HAND_SCALE");

		public static float HAND_SCALE_Y => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "HAND_SCALE_Y");

		public static float HAND_SCALE_OPPONENT => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "HAND_SCALE_OPPONENT");

		public static float HAND_SCALE_OPPONENT_Y => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "HAND_SCALE_OPPONENT_Y");

		public static int MAX_CARDS => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "ZoneHand", "MAX_CARDS");

		public static float CARD_WIDTH => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "CARD_WIDTH");

		public static float ANGLE_OF_CARDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "ANGLE_OF_CARDS");

		public static float DEFAULT_ANIMATE_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "DEFAULT_ANIMATE_TIME");

		public static float DRIFT_AMOUNT => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "DRIFT_AMOUNT");

		public static float Z_ROTATION_ON_LEFT => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "Z_ROTATION_ON_LEFT");

		public static float Z_ROTATION_ON_RIGHT => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "Z_ROTATION_ON_RIGHT");

		public static List<float> CARD_PIXEL_WIDTHS_TABLET => MonoClass.smethod_7<Class250<float>>(TritonHs.MainAssemblyPath, "", "ZoneHand", "CARD_PIXEL_WIDTHS_TABLET")?.method_25();

		public static List<float> CARD_PIXEL_WIDTHS_PHONE => MonoClass.smethod_7<Class250<float>>(TritonHs.MainAssemblyPath, "", "ZoneHand", "CARD_PIXEL_WIDTHS_PHONE")?.method_25();

		public static float RESISTANCE_BASE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "ZoneHand", "RESISTANCE_BASE");

		public int lastMousedOver => method_2<int>("lastMousedOver");

		public float m_maxWidth => method_2<float>("m_maxWidth");

		public bool m_doNotUpdateLayout => method_2<bool>("m_doNotUpdateLayout");

		public Vector3 centerOfHand => method_2<Vector3>("centerOfHand");

		public bool enemyHand => method_2<bool>("enemyHand");

		public bool m_handEnlarged => method_2<bool>("m_handEnlarged");

		public Vector3 m_startingPosition => method_2<Vector3>("m_startingPosition");

		public Vector3 m_startingScale => method_2<Vector3>("m_startingScale");

		public bool m_handMoving => method_2<bool>("m_handMoving");

		public bool m_targetingMode => method_2<bool>("m_targetingMode");

		public int m_touchedSlot => method_2<int>("m_touchedSlot");

		public CardStandIn m_hiddenStandIn => method_3<CardStandIn>("m_hiddenStandIn");

		public List<CardStandIn> standIns => method_3<Class271<CardStandIn>>("standIns")?.method_25();

		public bool m_flipHandCards => method_2<bool>("m_flipHandCards");

		public CardStandIn CurrentStandIn => method_14<CardStandIn>("get_CurrentStandIn", Array.Empty<object>());

		public ZoneHand(IntPtr address, string className)
			: base(address, className)
		{
		}

		public ZoneHand(IntPtr address)
			: this(address, "ZoneHand")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public int GetLastMousedOverCard()
		{
			return method_11<int>("GetLastMousedOverCard", Array.Empty<object>());
		}

		public bool IsHandScrunched()
		{
			return method_11<bool>("IsHandScrunched", Array.Empty<object>());
		}

		public void SetDoNotUpdateLayout(bool enable)
		{
			method_8("SetDoNotUpdateLayout", enable);
		}

		public bool IsDoNotUpdateLayout()
		{
			return method_11<bool>("IsDoNotUpdateLayout", Array.Empty<object>());
		}

		public void OnSpellPowerEntityEnteredPlay()
		{
			method_8("OnSpellPowerEntityEnteredPlay");
		}

		public void OnSpellPowerEntityMousedOver()
		{
			method_8("OnSpellPowerEntityMousedOver");
		}

		public void OnSpellPowerEntityMousedOut()
		{
			method_8("OnSpellPowerEntityMousedOut");
		}

		public float GetDefaultCardSpacing()
		{
			return method_11<float>("GetDefaultCardSpacing", Array.Empty<object>());
		}

		public new void UpdateLayout()
		{
			method_9("UpdateLayout", new Class276.Enum20[0]);
		}

		public void ForceStandInUpdate()
		{
			method_8("ForceStandInUpdate");
		}

		public void UpdateLayout(int slotMousedOver)
		{
			method_9("UpdateLayout", new Class276.Enum20[1] { Class276.Enum20.I4 }, slotMousedOver);
		}

		public void UpdateLayout(int slotMousedOver, bool forced)
		{
			method_9("UpdateLayout", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Boolean
			}, slotMousedOver, forced);
		}

		public void UpdateLayout(int slotMousedOver, bool forced, int overrideCardCount)
		{
			method_9("UpdateLayout", new Class276.Enum20[3]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Boolean,
				Class276.Enum20.I4
			}, slotMousedOver, forced, overrideCardCount);
		}

		public void HideCards()
		{
			method_8("HideCards");
		}

		public void ShowCards()
		{
			method_8("ShowCards");
		}

		public float GetCardWidth(int nCards)
		{
			return method_11<float>("GetCardWidth", new object[1] { nCards });
		}

		public bool TouchReceived()
		{
			return method_11<bool>("TouchReceived", Array.Empty<object>());
		}

		public void HandleInput()
		{
			method_8("HandleInput");
		}

		public void UpdateKeywordPanelsPosition(int slotMousedOver)
		{
			method_8("UpdateKeywordPanelsPosition", slotMousedOver);
		}

		public bool ShouldShowCardTooltipOnRight(Card card)
		{
			return method_11<bool>("ShouldShowCardTooltipOnRight", new object[1] { card });
		}

		public void ShowManaGems()
		{
			method_8("ShowManaGems");
		}

		public void HideManaGems()
		{
			method_8("HideManaGems");
		}

		public void SetHandEnlarged(bool enlarged)
		{
			method_8("SetHandEnlarged", enlarged);
		}

		public bool HandEnlarged()
		{
			return method_11<bool>("HandEnlarged", Array.Empty<object>());
		}

		public void SetFriendlyHeroTargetingMode(bool enable)
		{
			method_8("SetFriendlyHeroTargetingMode", enable);
		}

		public void UpdateLayoutImpl(int slotMousedOver, int overrideCardCount)
		{
			method_8("UpdateLayoutImpl", slotMousedOver, overrideCardCount);
		}

		public void CreateCardStandIn(Card card)
		{
			method_8("CreateCardStandIn", card);
		}

		public CardStandIn GetStandIn(Card card)
		{
			return method_14<CardStandIn>("GetStandIn", new object[1] { card });
		}

		public void MakeStandInInteractive(Card card)
		{
			method_8("MakeStandInInteractive", card);
		}

		public void BlowUpOldStandins()
		{
			method_8("BlowUpOldStandins");
		}

		public int GetCardSlot(Card card)
		{
			return method_11<int>("GetCardSlot", new object[1] { card });
		}

		public Vector3 GetCardPosition(Card card)
		{
			return method_10<Vector3>("GetCardPosition", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public Vector3 GetCardPosition(Card card, int overrideCardCount)
		{
			return method_10<Vector3>("GetCardPosition", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.I4
			}, new object[2] { card, overrideCardCount });
		}

		public Vector3 GetCardPosition(int slot, int overrideCardCount)
		{
			return method_10<Vector3>("GetCardPosition", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.I4
			}, new object[2] { slot, overrideCardCount });
		}

		public Vector3 GetCardRotation(Card card)
		{
			return method_10<Vector3>("GetCardRotation", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public Vector3 GetCardRotation(Card card, int overrideCardCount)
		{
			return method_10<Vector3>("GetCardRotation", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.I4
			}, new object[2] { card, overrideCardCount });
		}

		public Vector3 GetCardRotation(int slot, int overrideCardCount)
		{
			return method_10<Vector3>("GetCardRotation", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.I4
			}, new object[2] { slot, overrideCardCount });
		}

		public Vector3 GetCardScale()
		{
			return method_11<Vector3>("GetCardScale", Array.Empty<object>());
		}

		public Vector3 GetMouseOverCardPosition(Card card)
		{
			return method_11<Vector3>("GetMouseOverCardPosition", new object[1] { card });
		}

		public float GetCardSpacing()
		{
			return method_11<float>("GetCardSpacing", Array.Empty<object>());
		}

		public float MaxHandWidth()
		{
			return method_11<float>("MaxHandWidth", Array.Empty<object>());
		}

		public bool CanAnimateCard(Card card)
		{
			return method_11<bool>("CanAnimateCard", new object[1] { card });
		}

		public bool IsCardNotInEnemyHandAnymore(Card card)
		{
			return method_11<bool>("IsCardNotInEnemyHandAnymore", new object[1] { card });
		}

		public void UpdateCenterAndWidth()
		{
			method_8("UpdateCenterAndWidth");
		}

		public bool CanPlaySpellPowerHint(Card card)
		{
			return method_11<bool>("CanPlaySpellPowerHint", new object[1] { card });
		}

		public new bool AddCard(Card card)
		{
			return method_11<bool>("AddCard", new object[1] { card });
		}
	}
}
